08031 Abstracts Collection -- Software Engineering for Self-Adaptive Systems

From 13.01. to 18.01.2008, the Dagstuhl Seminar 08031 ``Software Engineering for Self-Adaptive Systems\u27\u27 was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed. Abstracts of the presentations given during the seminar as well as abstracts of seminar results and ideas are put together in this paper. The first section describes the seminar topics and goals in general. Links to extended abstracts or full papers are provided, if available

RELAX:a language to address uncertainty in self-adaptive systems requirement

Self-adaptive systems have the capability to autonomously modify their behavior at run-time in response to changes in their environment. Self-adaptation is particularly necessary for applications that must run continuously, even under adverse conditions and changing requirements; sample domains include automotive systems, telecommunications, and environmental monitoring systems. While a few techniques have been developed to support the monitoring and analysis of requirements for adaptive systems, limited attention has been paid to the actual creation and specication of requirements of self-adaptive systems. As a result, self-adaptivity is often constructed in an ad-hoc manner. In order to support the rigorous specication of adaptive systems requirements, this paper introduces RELAX, a new requirements language for self- adaptive systems that explicitly addresses uncertainty inherent in adaptive systems. We present the formal semantics for RELAX in terms of fuzzy logic, thus enabling a rigorous treatment of requirements that include uncertainty. RELAX enables developers to identify uncertainty in the requirements, thereby facilitating the design of systems that are, by denition, more exible and amenable to adaptation in a systematic fashion. We illustrate the use of RELAX on smart home applications, including an adaptive assisted living system

Addressing the Uncertainty Interaction Problem in Software-intensive Systems: Challenges and Desiderata. (Summary).

Software-intensive systems are increasingly used to support tasks that are typically characterized by high degrees of uncertainty. The modeling notations employed to design, verify, and operate such systems have increasingly started to capture different types of uncertainty, so that they can be explicitly considered when systems are developed and deployed. While these modeling paradigms consider different sources of uncertainty individually, these sources are rarely independent, and their interactions affect the achievement of system goals in subtle and often unpredictable ways. This vision paper describes the problem of uncertainty interaction in software-intensive systems, illustrating it on examples from relevant application domains. We then identify key open challenges that require further exploration, and define desiderata that future modeling notations and model-driven engineering research should consider to address these challenges.Universidad de Málaga. Campus de Excelencia Internacional Andalucía Tech

Automated Synthesis of Data Abstractions

ions Betty H.C. Cheng Department of Computer Science Michigan State University East Lansing, Michigan 48824 Abstract Research into the development of software tools that support formal methods is aimed at simplifying and providing assistance during the development of correct software. We have developed the Seed system that uses techniques amenable to automation in order to assist a user in the correct development of the building blocks of a large software system from user-supplied formal specifications. Seed accepts a formal specification of a problem written in predicate logic and generates annotated program source code satisfying the specification. The rules for choosing which programming language structures to synthesize are contained in a rule base; background knowledge and domainspecific information are entered into a fact base. During synthesis, Seed uses the fact base to disambiguate rule applications. In addition to primitive programming language constructs, such as assignmen..

Synthesizing Procedural Abstractions from Formal Specifications

ions from Formal Specifications Betty H.C. Cheng Department of Computer Science Michigan State University East Lansing, Michigan 48824 Abstract This paper describes the development of the Seed system, which demonstrates that the building blocks of a large software system can be correctly synthesized from user-supplied formal specifications using techniques amenable to automation. Seed accepts a formal specification of a problem written in predicate logic and generates annotated program source code satisfying the specification. In addition to primitive programming language constructs, Seed is capable of synthesizing recursive and non-recursive procedures and functions, and abstract data types. 1 Introduction Research concerning the use of formal methods in software tools seeks to facilitate the development of correct software [14, 8, 11, 13]. Our objective is to build a software development environment consisting of tools that will support the use of formal methods in all phases ..

Pattern-based modeling and analysis of failsafe fault-tolerance in UML

In order to facilitate incremental modeling and analysis of fault-tolerant embedded systems, we introduce an object analysis pattern, called the detector pattern, that provides a reusable strategy for capturing the requirements of fail-safe fault-tolerance in an existing conceptual model, where a failsafe system satisfies its safety requirements even when faults occur. We also present a method that (i) uses the detector pattern to help create a behavioral model of a fail-safe fault-tolerant system in UML, (ii) generates and model checks formal models of UML state diagrams of the fault-tolerant system, and (iii) visualizes the model checking results in terms of the UML diagrams to facilitate model refinement. We demonstrate our analysis method in the context of an industrial automotive application. © 2007 IEEE

A pattern-based approach for modeling and analyzing error recovery

Several approaches exist for modeling recovery of faulttolerant systems during the requirements analysis phase. Most of these approaches are based on design techniques for recovery. Such designbiased analysis methods unnecessarily constrain an analyst when specifying recovery requirements. To remedy such restrictions, we present an object analysis pattern, called the corrector pattern, that provides a generic reusable strategy for modeling error recovery requirements for embedded systems. In addition to templates for constructing structural and behavioral models of recovery requirements, the corrector pattern also contains templates for specifying properties that can be formally verified to ensure the consistency between recovery and functional requirements. Additional property templates can be instantiated and verified to ensure the fault-tolerance of the system to which the corrector pattern has been applied. We validate our analysis method in terms of UML diagrams, where we (1) use the corrector pattern to model recovery in UML behavioral models, (2) generate and model check formal models of the resulting UML models, and (3) visualize the model checking results in terms of the UML diagrams to facilitate model refinement. We demonstrate our analysis method in the context of an industrial automotive application. © Springer-Verlag Berlin Heidelberg 2007

Pattern-Based Modeling and Analysis of Failsafe Fault-Tolerance in UML

In order to facilitate incremental modeling and analysis of fault-tolerant embedded systems, we introduce an object analysis pattern, called the detector pattern, that provides a reusable strategy for capturing the requirements of fail-safe fault-tolerance in an existing conceptual model, where a failsafe system satisfies its safety requirements even when faults occur. We also present a method that (i) uses the detector pattern to help create a behavioral model of a fail-safe fault-tolerant system in UML, (ii) generates and model checks formal models of UML state diagrams of the fault-tolerant system, and (iii) visualizes the model checking results in terms of the UML diagrams to facilitate model refinement. We demonstrate our analysis method in the context of an industrial automotive application. © 2007 IEEE